home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / xmllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  26KB  |  937 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''A parser for XML, using the derived class as static DTD.'''
  5. import re
  6. import string
  7. import warnings
  8. warnings.warn('The xmllib module is obsolete.  Use xml.sax instead.', DeprecationWarning, 2)
  9. del warnings
  10. version = '0.3'
  11.  
  12. class Error(RuntimeError):
  13.     pass
  14.  
  15. _S = '[ \t\r\n]+'
  16. _opS = '[ \t\r\n]*'
  17. _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'
  18. _QStr = '(?:\'[^\']*\'|"[^"]*")'
  19. illegal = re.compile('[^\t\r\n -~\xa0-\xff]')
  20. interesting = re.compile('[]&<]')
  21. amp = re.compile('&')
  22. ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')
  23. entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')
  24. charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')
  25. space = re.compile(_S + '$')
  26. newline = re.compile('\n')
  27. attrfind = re.compile(_S + '(?P<name>' + _Name + ')(' + _opS + '=' + _opS + '(?P<value>' + _QStr + '|[-a-zA-Z0-9.:+*%?!\\(\\)_#=~]+))?')
  28. starttagopen = re.compile('<' + _Name)
  29. starttagend = re.compile(_opS + '(?P<slash>/?)>')
  30. starttagmatch = re.compile('<(?P<tagname>' + _Name + ')(?P<attrs>(?:' + attrfind.pattern + ')*)' + starttagend.pattern)
  31. endtagopen = re.compile('</')
  32. endbracket = re.compile(_opS + '>')
  33. endbracketfind = re.compile('(?:[^>\'"]|' + _QStr + ')*>')
  34. tagfind = re.compile(_Name)
  35. cdataopen = re.compile('<!\\[CDATA\\[')
  36. cdataclose = re.compile('\\]\\]>')
  37. _SystemLiteral = '(?P<%s>' + _QStr + ')'
  38. _PublicLiteral = '(?P<%s>"[-\'\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|\'[-\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*\')'
  39. _ExternalId = '(?:SYSTEM|PUBLIC' + _S + _PublicLiteral % 'pubid' + ')' + _S + _SystemLiteral % 'syslit'
  40. doctype = re.compile('<!DOCTYPE' + _S + '(?P<name>' + _Name + ')(?:' + _S + _ExternalId + ')?' + _opS)
  41. xmldecl = re.compile('<\\?xml' + _S + 'version' + _opS + '=' + _opS + '(?P<version>' + _QStr + ')' + '(?:' + _S + 'encoding' + _opS + '=' + _opS + '(?P<encoding>\'[A-Za-z][-A-Za-z0-9._]*\'|"[A-Za-z][-A-Za-z0-9._]*"))?(?:' + _S + 'standalone' + _opS + '=' + _opS + '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?' + _opS + '\\?>')
  42. procopen = re.compile('<\\?(?P<proc>' + _Name + ')' + _opS)
  43. procclose = re.compile(_opS + '\\?>')
  44. commentopen = re.compile('<!--')
  45. commentclose = re.compile('-->')
  46. doubledash = re.compile('--')
  47. attrtrans = string.maketrans(' \r\n\t', '    ')
  48. _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'
  49. ncname = re.compile(_NCName + '$')
  50. qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?(?P<local>' + _NCName + ')$')
  51. xmlns = re.compile('xmlns(?::(?P<ncname>' + _NCName + '))?$')
  52.  
  53. class XMLParser:
  54.     attributes = { }
  55.     elements = { }
  56.     __accept_unquoted_attributes = 0
  57.     __accept_missing_endtag_name = 0
  58.     __map_case = 0
  59.     __accept_utf8 = 0
  60.     __translate_attribute_references = 1
  61.     
  62.     def __init__(self, **kw):
  63.         self._XMLParser__fixed = 0
  64.         if 'accept_unquoted_attributes' in kw:
  65.             self._XMLParser__accept_unquoted_attributes = kw['accept_unquoted_attributes']
  66.         if 'accept_missing_endtag_name' in kw:
  67.             self._XMLParser__accept_missing_endtag_name = kw['accept_missing_endtag_name']
  68.         if 'map_case' in kw:
  69.             self._XMLParser__map_case = kw['map_case']
  70.         if 'accept_utf8' in kw:
  71.             self._XMLParser__accept_utf8 = kw['accept_utf8']
  72.         if 'translate_attribute_references' in kw:
  73.             self._XMLParser__translate_attribute_references = kw['translate_attribute_references']
  74.         self.reset()
  75.  
  76.     
  77.     def __fixelements(self):
  78.         self._XMLParser__fixed = 1
  79.         self.elements = { }
  80.         self._XMLParser__fixdict(self.__dict__)
  81.         self._XMLParser__fixclass(self.__class__)
  82.  
  83.     
  84.     def __fixclass(self, kl):
  85.         self._XMLParser__fixdict(kl.__dict__)
  86.         for k in kl.__bases__:
  87.             self._XMLParser__fixclass(k)
  88.         
  89.  
  90.     
  91.     def __fixdict(self, dict):
  92.         for key in dict.keys():
  93.             if key[:6] == 'start_':
  94.                 tag = key[6:]
  95.                 (start, end) = self.elements.get(tag, (None, None))
  96.                 if start is None:
  97.                     self.elements[tag] = (getattr(self, key), end)
  98.                 
  99.             if key[:4] == 'end_':
  100.                 tag = key[4:]
  101.                 (start, end) = self.elements.get(tag, (None, None))
  102.                 if end is None:
  103.                     self.elements[tag] = (start, getattr(self, key))
  104.                 
  105.  
  106.     
  107.     def reset(self):
  108.         self.rawdata = ''
  109.         self.stack = []
  110.         self.nomoretags = 0
  111.         self.literal = 0
  112.         self.lineno = 1
  113.         self._XMLParser__at_start = 1
  114.         self._XMLParser__seen_doctype = None
  115.         self._XMLParser__seen_starttag = 0
  116.         self._XMLParser__use_namespaces = 0
  117.         self._XMLParser__namespaces = {
  118.             'xml': None }
  119.         if self.elements is XMLParser.elements:
  120.             self._XMLParser__fixelements()
  121.  
  122.     
  123.     def setnomoretags(self):
  124.         self.nomoretags = self.literal = 1
  125.  
  126.     
  127.     def setliteral(self, *args):
  128.         self.literal = 1
  129.  
  130.     
  131.     def feed(self, data):
  132.         self.rawdata = self.rawdata + data
  133.         self.goahead(0)
  134.  
  135.     
  136.     def close(self):
  137.         self.goahead(1)
  138.         if self._XMLParser__fixed:
  139.             self._XMLParser__fixed = 0
  140.             del self.elements
  141.  
  142.     
  143.     def translate_references(self, data, all = 1):
  144.         if not self._XMLParser__translate_attribute_references:
  145.             return data
  146.         i = None
  147.         while None:
  148.             res = amp.search(data, i)
  149.             if res is None:
  150.                 return data
  151.             s = None.start(0)
  152.             res = ref.match(data, s)
  153.             if res is None:
  154.                 self.syntax_error("bogus `&'")
  155.                 i = s + 1
  156.                 continue
  157.             i = res.end(0)
  158.             str = res.group(1)
  159.             rescan = 0
  160.             if str[0] == '#':
  161.                 if str[1] == 'x':
  162.                     str = chr(int(str[2:], 16))
  163.                 else:
  164.                     str = chr(int(str[1:]))
  165.                 if data[i - 1] != ';':
  166.                     self.syntax_error("`;' missing after char reference")
  167.                     i = i - 1
  168.                 
  169.             elif all:
  170.                 if str in self.entitydefs:
  171.                     str = self.entitydefs[str]
  172.                     rescan = 1
  173.                 elif data[i - 1] != ';':
  174.                     self.syntax_error("bogus `&'")
  175.                     i = s + 1
  176.                     continue
  177.                 else:
  178.                     self.syntax_error("reference to unknown entity `&%s;'" % str)
  179.                     str = '&' + str + ';'
  180.             elif data[i - 1] != ';':
  181.                 self.syntax_error("bogus `&'")
  182.                 i = s + 1
  183.                 continue
  184.             data = data[:s] + str + data[i:]
  185.             if rescan:
  186.                 i = s
  187.                 continue
  188.             i = s + len(str)
  189.             continue
  190.             return None
  191.  
  192.     
  193.     def getnamespace(self):
  194.         nsdict = { }
  195.         for t, d, nst in self.stack:
  196.             nsdict.update(d)
  197.         
  198.         return nsdict
  199.  
  200.     
  201.     def goahead(self, end):
  202.         rawdata = self.rawdata
  203.         i = 0
  204.         n = len(rawdata)
  205.         while i < n:
  206.             if i > 0:
  207.                 self._XMLParser__at_start = 0
  208.             if self.nomoretags:
  209.                 data = rawdata[i:n]
  210.                 self.handle_data(data)
  211.                 self.lineno = self.lineno + data.count('\n')
  212.                 i = n
  213.                 break
  214.             res = interesting.search(rawdata, i)
  215.             if res:
  216.                 j = res.start(0)
  217.             else:
  218.                 j = n
  219.             if i < j:
  220.                 data = rawdata[i:j]
  221.                 if self._XMLParser__at_start and space.match(data) is None:
  222.                     self.syntax_error('illegal data at start of file')
  223.                 self._XMLParser__at_start = 0
  224.                 if not (self.stack) and space.match(data) is None:
  225.                     self.syntax_error('data not in content')
  226.                 if not (self._XMLParser__accept_utf8) and illegal.search(data):
  227.                     self.syntax_error('illegal character in content')
  228.                 self.handle_data(data)
  229.                 self.lineno = self.lineno + data.count('\n')
  230.             i = j
  231.             if i == n:
  232.                 break
  233.             if rawdata[i] == '<':
  234.                 if starttagopen.match(rawdata, i):
  235.                     if self.literal:
  236.                         data = rawdata[i]
  237.                         self.handle_data(data)
  238.                         self.lineno = self.lineno + data.count('\n')
  239.                         i = i + 1
  240.                         continue
  241.                     k = self.parse_starttag(i)
  242.                     if k < 0:
  243.                         break
  244.                     self._XMLParser__seen_starttag = 1
  245.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  246.                     i = k
  247.                     continue
  248.                 if endtagopen.match(rawdata, i):
  249.                     k = self.parse_endtag(i)
  250.                     if k < 0:
  251.                         break
  252.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  253.                     i = k
  254.                     continue
  255.                 if commentopen.match(rawdata, i):
  256.                     if self.literal:
  257.                         data = rawdata[i]
  258.                         self.handle_data(data)
  259.                         self.lineno = self.lineno + data.count('\n')
  260.                         i = i + 1
  261.                         continue
  262.                     k = self.parse_comment(i)
  263.                     if k < 0:
  264.                         break
  265.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  266.                     i = k
  267.                     continue
  268.                 if cdataopen.match(rawdata, i):
  269.                     k = self.parse_cdata(i)
  270.                     if k < 0:
  271.                         break
  272.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  273.                     i = k
  274.                     continue
  275.                 res = xmldecl.match(rawdata, i)
  276.                 if res:
  277.                     if not self._XMLParser__at_start:
  278.                         self.syntax_error('<?xml?> declaration not at start of document')
  279.                     (version, encoding, standalone) = res.group('version', 'encoding', 'standalone')
  280.                     if version[1:-1] != '1.0':
  281.                         raise Error('only XML version 1.0 supported')
  282.                     if encoding:
  283.                         encoding = encoding[1:-1]
  284.                     if standalone:
  285.                         standalone = standalone[1:-1]
  286.                     self.handle_xml(encoding, standalone)
  287.                     i = res.end(0)
  288.                     continue
  289.                 res = procopen.match(rawdata, i)
  290.                 if res:
  291.                     k = self.parse_proc(i)
  292.                     if k < 0:
  293.                         break
  294.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  295.                     i = k
  296.                     continue
  297.                 res = doctype.match(rawdata, i)
  298.                 if res:
  299.                     if self.literal:
  300.                         data = rawdata[i]
  301.                         self.handle_data(data)
  302.                         self.lineno = self.lineno + data.count('\n')
  303.                         i = i + 1
  304.                         continue
  305.                     if self._XMLParser__seen_doctype:
  306.                         self.syntax_error('multiple DOCTYPE elements')
  307.                     if self._XMLParser__seen_starttag:
  308.                         self.syntax_error('DOCTYPE not at beginning of document')
  309.                     k = self.parse_doctype(res)
  310.                     if k < 0:
  311.                         break
  312.                     self._XMLParser__seen_doctype = res.group('name')
  313.                     if self._XMLParser__map_case:
  314.                         self._XMLParser__seen_doctype = self._XMLParser__seen_doctype.lower()
  315.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  316.                     i = k
  317.                     continue
  318.                 
  319.             elif rawdata[i] == '&':
  320.                 if self.literal:
  321.                     data = rawdata[i]
  322.                     self.handle_data(data)
  323.                     i = i + 1
  324.                     continue
  325.                 res = charref.match(rawdata, i)
  326.                 if res is not None:
  327.                     i = res.end(0)
  328.                     if rawdata[i - 1] != ';':
  329.                         self.syntax_error("`;' missing in charref")
  330.                         i = i - 1
  331.                     if not self.stack:
  332.                         self.syntax_error('data not in content')
  333.                     self.handle_charref(res.group('char')[:-1])
  334.                     self.lineno = self.lineno + res.group(0).count('\n')
  335.                     continue
  336.                 res = entityref.match(rawdata, i)
  337.                 if res is not None:
  338.                     i = res.end(0)
  339.                     if rawdata[i - 1] != ';':
  340.                         self.syntax_error("`;' missing in entityref")
  341.                         i = i - 1
  342.                     name = res.group('name')
  343.                     if self._XMLParser__map_case:
  344.                         name = name.lower()
  345.                     if name in self.entitydefs:
  346.                         self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]
  347.                         n = len(rawdata)
  348.                         i = res.start(0)
  349.                     else:
  350.                         self.unknown_entityref(name)
  351.                     self.lineno = self.lineno + res.group(0).count('\n')
  352.                     continue
  353.                 
  354.             elif rawdata[i] == ']':
  355.                 if self.literal:
  356.                     data = rawdata[i]
  357.                     self.handle_data(data)
  358.                     i = i + 1
  359.                     continue
  360.                 if n - i < 3:
  361.                     break
  362.                 if cdataclose.match(rawdata, i):
  363.                     self.syntax_error("bogus `]]>'")
  364.                 self.handle_data(rawdata[i])
  365.                 i = i + 1
  366.                 continue
  367.             else:
  368.                 raise Error('neither < nor & ??')
  369.         if i > 0:
  370.             self._XMLParser__at_start = 0
  371.         if end and i < n:
  372.             data = rawdata[i]
  373.             self.syntax_error("bogus `%s'" % data)
  374.             if not (self._XMLParser__accept_utf8) and illegal.search(data):
  375.                 self.syntax_error('illegal character in content')
  376.             self.handle_data(data)
  377.             self.lineno = self.lineno + data.count('\n')
  378.             self.rawdata = rawdata[i + 1:]
  379.             return self.goahead(end)
  380.         self.rawdata = None[i:]
  381.         if end:
  382.             if not self._XMLParser__seen_starttag:
  383.                 self.syntax_error('no elements in file')
  384.             if self.stack:
  385.                 self.syntax_error('missing end tags')
  386.                 while self.stack:
  387.                     self.finish_endtag(self.stack[-1][0])
  388.             
  389.  
  390.     
  391.     def parse_comment(self, i):
  392.         rawdata = self.rawdata
  393.         if rawdata[i:i + 4] != '<!--':
  394.             raise Error('unexpected call to handle_comment')
  395.         res = commentclose.search(rawdata, i + 4)
  396.         if res is None:
  397.             return -1
  398.         if None.search(rawdata, i + 4, res.start(0)):
  399.             self.syntax_error("`--' inside comment")
  400.         if rawdata[res.start(0) - 1] == '-':
  401.             self.syntax_error('comment cannot end in three dashes')
  402.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 4, res.start(0)):
  403.             self.syntax_error('illegal character in comment')
  404.         self.handle_comment(rawdata[i + 4:res.start(0)])
  405.         return res.end(0)
  406.  
  407.     
  408.     def parse_doctype(self, res):
  409.         rawdata = self.rawdata
  410.         n = len(rawdata)
  411.         name = res.group('name')
  412.         if self._XMLParser__map_case:
  413.             name = name.lower()
  414.         (pubid, syslit) = res.group('pubid', 'syslit')
  415.         if pubid is not None:
  416.             pubid = pubid[1:-1]
  417.             pubid = ' '.join(pubid.split())
  418.         if syslit is not None:
  419.             syslit = syslit[1:-1]
  420.         j = k = res.end(0)
  421.         if k >= n:
  422.             return -1
  423.         if None[k] == '[':
  424.             level = 0
  425.             k = k + 1
  426.             dq = sq = 0
  427.             while k < n:
  428.                 c = rawdata[k]
  429.                 if not sq and c == '"':
  430.                     dq = not dq
  431.                 elif not dq and c == "'":
  432.                     sq = not sq
  433.                 elif not sq:
  434.                     if dq:
  435.                         pass
  436.                     elif level <= 0 and c == ']':
  437.                         res = endbracket.match(rawdata, k + 1)
  438.                         if res is None:
  439.                             return -1
  440.                         None.handle_doctype(name, pubid, syslit, rawdata[j + 1:k])
  441.                         return res.end(0)
  442.                     if c == '<':
  443.                         level = level + 1
  444.                     elif c == '>':
  445.                         level = level - 1
  446.                         if level < 0:
  447.                             self.syntax_error("bogus `>' in DOCTYPE")
  448.                         
  449.                 k = k + 1
  450.         res = endbracketfind.match(rawdata, k)
  451.         if res is None:
  452.             return -1
  453.         if None.match(rawdata, k) is None:
  454.             self.syntax_error('garbage in DOCTYPE')
  455.         self.handle_doctype(name, pubid, syslit, None)
  456.         return res.end(0)
  457.  
  458.     
  459.     def parse_cdata(self, i):
  460.         rawdata = self.rawdata
  461.         if rawdata[i:i + 9] != '<![CDATA[':
  462.             raise Error('unexpected call to parse_cdata')
  463.         res = cdataclose.search(rawdata, i + 9)
  464.         if res is None:
  465.             return -1
  466.         if not (None._XMLParser__accept_utf8) and illegal.search(rawdata, i + 9, res.start(0)):
  467.             self.syntax_error('illegal character in CDATA')
  468.         if not self.stack:
  469.             self.syntax_error('CDATA not in content')
  470.         self.handle_cdata(rawdata[i + 9:res.start(0)])
  471.         return res.end(0)
  472.  
  473.     __xml_namespace_attributes = {
  474.         'ns': None,
  475.         'src': None,
  476.         'prefix': None }
  477.     
  478.     def parse_proc(self, i):
  479.         rawdata = self.rawdata
  480.         end = procclose.search(rawdata, i)
  481.         if end is None:
  482.             return -1
  483.         j = None.start(0)
  484.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 2, j):
  485.             self.syntax_error('illegal character in processing instruction')
  486.         res = tagfind.match(rawdata, i + 2)
  487.         if res is None:
  488.             raise Error('unexpected call to parse_proc')
  489.         k = res.end(0)
  490.         name = res.group(0)
  491.         if self._XMLParser__map_case:
  492.             name = name.lower()
  493.         if name == 'xml:namespace':
  494.             self.syntax_error('old-fashioned namespace declaration')
  495.             self._XMLParser__use_namespaces = -1
  496.             if self._XMLParser__seen_doctype or self._XMLParser__seen_starttag:
  497.                 self.syntax_error('xml:namespace declaration too late in document')
  498.             (attrdict, namespace, k) = self.parse_attributes(name, k, j)
  499.             if namespace:
  500.                 self.syntax_error('namespace declaration inside namespace declaration')
  501.             for attrname in attrdict.keys():
  502.                 if attrname not in self._XMLParser__xml_namespace_attributes:
  503.                     self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)
  504.                     continue
  505.             if 'ns' not in attrdict or 'prefix' not in attrdict:
  506.                 self.syntax_error('xml:namespace without required attributes')
  507.             prefix = attrdict.get('prefix')
  508.             if ncname.match(prefix) is None:
  509.                 self.syntax_error('xml:namespace illegal prefix value')
  510.                 return end.end(0)
  511.             if None in self._XMLParser__namespaces:
  512.                 self.syntax_error('xml:namespace prefix not unique')
  513.             self._XMLParser__namespaces[prefix] = attrdict['ns']
  514.         elif name.lower() == 'xml':
  515.             self.syntax_error('illegal processing instruction target name')
  516.         self.handle_proc(name, rawdata[k:j])
  517.         return end.end(0)
  518.  
  519.     
  520.     def parse_attributes(self, tag, i, j):
  521.         rawdata = self.rawdata
  522.         attrdict = { }
  523.         namespace = { }
  524.         while i < j:
  525.             res = attrfind.match(rawdata, i)
  526.             if res is None:
  527.                 break
  528.             (attrname, attrvalue) = res.group('name', 'value')
  529.             if self._XMLParser__map_case:
  530.                 attrname = attrname.lower()
  531.             i = res.end(0)
  532.             if attrvalue is None:
  533.                 self.syntax_error("no value specified for attribute `%s'" % attrname)
  534.                 attrvalue = attrname
  535.             elif "'" == "'":
  536.                 pass
  537.             elif not "'" == "'" == attrvalue[-1:]:
  538.                 if '"' == '"':
  539.                     pass
  540.                 elif '"' == attrvalue[-1:]:
  541.                     attrvalue = attrvalue[1:-1]
  542.                 elif not self._XMLParser__accept_unquoted_attributes:
  543.                     self.syntax_error("attribute `%s' value not quoted" % attrname)
  544.                 res = xmlns.match(attrname)
  545.                 if res is not None:
  546.                     ncname = res.group('ncname')
  547.                     None[namespace if not attrvalue else ''] = '"' == attrvalue[-1:]
  548.                     if not self._XMLParser__use_namespaces:
  549.                         self._XMLParser__use_namespaces = len(self.stack) + 1
  550.                         continue
  551.                         continue
  552.             if '<' in attrvalue:
  553.                 self.syntax_error("`<' illegal in attribute value")
  554.             if attrname in attrdict:
  555.                 self.syntax_error("attribute `%s' specified twice" % attrname)
  556.             attrvalue = attrvalue.translate(attrtrans)
  557.             attrdict[attrname] = self.translate_references(attrvalue)
  558.         return (attrdict, namespace, i)
  559.  
  560.     
  561.     def parse_starttag(self, i):
  562.         rawdata = self.rawdata
  563.         end = endbracketfind.match(rawdata, i + 1)
  564.         if end is None:
  565.             return -1
  566.         tag = None.match(rawdata, i)
  567.         if tag is None or tag.end(0) != end.end(0):
  568.             self.syntax_error('garbage in starttag')
  569.             return end.end(0)
  570.         nstag = tagname = None.group('tagname')
  571.         if self._XMLParser__map_case:
  572.             nstag = tagname = nstag.lower()
  573.         if not (self._XMLParser__seen_starttag) and self._XMLParser__seen_doctype and tagname != self._XMLParser__seen_doctype:
  574.             self.syntax_error('starttag does not match DOCTYPE')
  575.         if self._XMLParser__seen_starttag and not (self.stack):
  576.             self.syntax_error('multiple elements on top level')
  577.         (k, j) = tag.span('attrs')
  578.         (attrdict, nsdict, k) = self.parse_attributes(tagname, k, j)
  579.         self.stack.append((tagname, nsdict, nstag))
  580.         if self._XMLParser__use_namespaces:
  581.             res = qname.match(tagname)
  582.         else:
  583.             res = None
  584.         if res is not None:
  585.             (prefix, nstag) = res.group('prefix', 'local')
  586.             if prefix is None:
  587.                 prefix = ''
  588.             ns = None
  589.             for t, d, nst in self.stack:
  590.                 if prefix in d:
  591.                     ns = d[prefix]
  592.                     continue
  593.             if ns is None and prefix != '':
  594.                 ns = self._XMLParser__namespaces.get(prefix)
  595.             if ns is not None:
  596.                 nstag = ns + ' ' + nstag
  597.             elif prefix != '':
  598.                 nstag = prefix + ':' + nstag
  599.             self.stack[-1] = (tagname, nsdict, nstag)
  600.         attrnamemap = { }
  601.         for key in attrdict.keys():
  602.             attrnamemap[key] = key
  603.         
  604.         if self._XMLParser__use_namespaces:
  605.             nattrdict = { }
  606.             for key, val in attrdict.items():
  607.                 okey = key
  608.                 res = qname.match(key)
  609.                 if res is not None:
  610.                     (aprefix, key) = res.group('prefix', 'local')
  611.                     if self._XMLParser__map_case:
  612.                         key = key.lower()
  613.                     if aprefix is not None:
  614.                         ans = None
  615.                         for t, d, nst in self.stack:
  616.                             if aprefix in d:
  617.                                 ans = d[aprefix]
  618.                                 continue
  619.                         if ans is None:
  620.                             ans = self._XMLParser__namespaces.get(aprefix)
  621.                         if ans is not None:
  622.                             key = ans + ' ' + key
  623.                         else:
  624.                             key = aprefix + ':' + key
  625.                     
  626.                 nattrdict[key] = val
  627.                 attrnamemap[key] = okey
  628.             
  629.             attrdict = nattrdict
  630.         attributes = self.attributes.get(nstag)
  631.         if attributes is not None:
  632.             for key in attrdict.keys():
  633.                 if key not in attributes:
  634.                     self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))
  635.                     continue
  636.             for key, val in attributes.items():
  637.                 if val is not None and key not in attrdict:
  638.                     attrdict[key] = val
  639.                     continue
  640.         method = self.elements.get(nstag, (None, None))[0]
  641.         self.finish_starttag(nstag, attrdict, method)
  642.         if tag.group('slash') == '/':
  643.             self.finish_endtag(tagname)
  644.         return tag.end(0)
  645.  
  646.     
  647.     def parse_endtag(self, i):
  648.         rawdata = self.rawdata
  649.         end = endbracketfind.match(rawdata, i + 1)
  650.         if end is None:
  651.             return -1
  652.         res = None.match(rawdata, i + 2)
  653.         if res is None:
  654.             if self.literal:
  655.                 self.handle_data(rawdata[i])
  656.                 return i + 1
  657.             if not None._XMLParser__accept_missing_endtag_name:
  658.                 self.syntax_error('no name specified in end tag')
  659.             tag = self.stack[-1][0]
  660.             k = i + 2
  661.         else:
  662.             tag = res.group(0)
  663.             if self._XMLParser__map_case:
  664.                 tag = tag.lower()
  665.             if self.literal:
  666.                 if not (self.stack) or tag != self.stack[-1][0]:
  667.                     self.handle_data(rawdata[i])
  668.                     return i + 1
  669.             k = res.end(0)
  670.         if endbracket.match(rawdata, k) is None:
  671.             self.syntax_error('garbage in end tag')
  672.         self.finish_endtag(tag)
  673.         return end.end(0)
  674.  
  675.     
  676.     def finish_starttag(self, tagname, attrdict, method):
  677.         if method is not None:
  678.             self.handle_starttag(tagname, method, attrdict)
  679.         else:
  680.             self.unknown_starttag(tagname, attrdict)
  681.  
  682.     
  683.     def finish_endtag(self, tag):
  684.         self.literal = 0
  685.         if not tag:
  686.             self.syntax_error('name-less end tag')
  687.             found = len(self.stack) - 1
  688.             if found < 0:
  689.                 self.unknown_endtag(tag)
  690.                 return None
  691.         found = -1
  692.         for i in range(len(self.stack)):
  693.             if tag == self.stack[i][0]:
  694.                 found = i
  695.                 continue
  696.         if found == -1:
  697.             self.syntax_error('unopened end tag')
  698.             return None
  699.         if len(self.stack) > found:
  700.             if found < len(self.stack) - 1:
  701.                 self.syntax_error('missing close tag for %s' % self.stack[-1][2])
  702.             nstag = self.stack[-1][2]
  703.             method = self.elements.get(nstag, (None, None))[1]
  704.             if method is not None:
  705.                 self.handle_endtag(nstag, method)
  706.             else:
  707.                 self.unknown_endtag(nstag)
  708.             if self._XMLParser__use_namespaces == len(self.stack):
  709.                 self._XMLParser__use_namespaces = 0
  710.             del self.stack[-1]
  711.  
  712.     
  713.     def handle_xml(self, encoding, standalone):
  714.         pass
  715.  
  716.     
  717.     def handle_doctype(self, tag, pubid, syslit, data):
  718.         pass
  719.  
  720.     
  721.     def handle_starttag(self, tag, method, attrs):
  722.         method(attrs)
  723.  
  724.     
  725.     def handle_endtag(self, tag, method):
  726.         method()
  727.  
  728.     
  729.     def handle_charref(self, name):
  730.         
  731.         try:
  732.             if name[0] == 'x':
  733.                 n = int(name[1:], 16)
  734.             else:
  735.                 n = int(name)
  736.         except ValueError:
  737.             self.unknown_charref(name)
  738.             return None
  739.  
  740.         if n <= n:
  741.             pass
  742.         elif not n <= 255:
  743.             self.unknown_charref(name)
  744.             return None
  745.         self.handle_data(chr(n))
  746.  
  747.     entitydefs = {
  748.         'lt': '<',
  749.         'gt': '>',
  750.         'amp': '&',
  751.         'quot': '"',
  752.         'apos': ''' }
  753.     
  754.     def handle_data(self, data):
  755.         pass
  756.  
  757.     
  758.     def handle_cdata(self, data):
  759.         pass
  760.  
  761.     
  762.     def handle_comment(self, data):
  763.         pass
  764.  
  765.     
  766.     def handle_proc(self, name, data):
  767.         pass
  768.  
  769.     
  770.     def syntax_error(self, message):
  771.         raise Error('Syntax error at line %d: %s' % (self.lineno, message))
  772.  
  773.     
  774.     def unknown_starttag(self, tag, attrs):
  775.         pass
  776.  
  777.     
  778.     def unknown_endtag(self, tag):
  779.         pass
  780.  
  781.     
  782.     def unknown_charref(self, ref):
  783.         pass
  784.  
  785.     
  786.     def unknown_entityref(self, name):
  787.         self.syntax_error("reference to unknown entity `&%s;'" % name)
  788.  
  789.  
  790.  
  791. class TestXMLParser(XMLParser):
  792.     
  793.     def __init__(self, **kw):
  794.         self.testdata = ''
  795.         XMLParser.__init__(self, **kw)
  796.  
  797.     
  798.     def handle_xml(self, encoding, standalone):
  799.         self.flush()
  800.         print 'xml: encoding =', encoding, 'standalone =', standalone
  801.  
  802.     
  803.     def handle_doctype(self, tag, pubid, syslit, data):
  804.         self.flush()
  805.         print 'DOCTYPE:', tag, repr(data)
  806.  
  807.     
  808.     def handle_data(self, data):
  809.         self.testdata = self.testdata + data
  810.         if len(repr(self.testdata)) >= 70:
  811.             self.flush()
  812.  
  813.     
  814.     def flush(self):
  815.         data = self.testdata
  816.         if data:
  817.             self.testdata = ''
  818.             print 'data:', repr(data)
  819.  
  820.     
  821.     def handle_cdata(self, data):
  822.         self.flush()
  823.         print 'cdata:', repr(data)
  824.  
  825.     
  826.     def handle_proc(self, name, data):
  827.         self.flush()
  828.         print 'processing:', name, repr(data)
  829.  
  830.     
  831.     def handle_comment(self, data):
  832.         self.flush()
  833.         r = repr(data)
  834.         if len(r) > 68:
  835.             r = r[:32] + '...' + r[-32:]
  836.         print 'comment:', r
  837.  
  838.     
  839.     def syntax_error(self, message):
  840.         print 'error at line %d:' % self.lineno, message
  841.  
  842.     
  843.     def unknown_starttag(self, tag, attrs):
  844.         self.flush()
  845.         if not attrs:
  846.             print 'start tag: <' + tag + '>'
  847.         else:
  848.             print 'start tag: <' + tag,
  849.             for name, value in attrs.items():
  850.                 print name + '=' + '"' + value + '"',
  851.             
  852.             print '>'
  853.  
  854.     
  855.     def unknown_endtag(self, tag):
  856.         self.flush()
  857.         print 'end tag: </' + tag + '>'
  858.  
  859.     
  860.     def unknown_entityref(self, ref):
  861.         self.flush()
  862.         print '*** unknown entity ref: &' + ref + ';'
  863.  
  864.     
  865.     def unknown_charref(self, ref):
  866.         self.flush()
  867.         print '*** unknown char ref: &#' + ref + ';'
  868.  
  869.     
  870.     def close(self):
  871.         XMLParser.close(self)
  872.         self.flush()
  873.  
  874.  
  875.  
  876. def test(args = None):
  877.     import sys as sys
  878.     import getopt as getopt
  879.     time = time
  880.     import time
  881.     if not args:
  882.         args = sys.argv[1:]
  883.     (opts, args) = getopt.getopt(args, 'st')
  884.     klass = TestXMLParser
  885.     do_time = 0
  886.     for o, a in opts:
  887.         if o == '-s':
  888.             klass = XMLParser
  889.             continue
  890.         if o == '-t':
  891.             do_time = 1
  892.             continue
  893.     if args:
  894.         file = args[0]
  895.     else:
  896.         file = 'test.xml'
  897.     if file == '-':
  898.         f = sys.stdin
  899.     else:
  900.         
  901.         try:
  902.             f = open(file, 'r')
  903.         except IOError:
  904.             msg = None
  905.             print file, ':', msg
  906.             sys.exit(1)
  907.  
  908.     data = f.read()
  909.     if f is not sys.stdin:
  910.         f.close()
  911.     x = klass()
  912.     t0 = time()
  913.     
  914.     try:
  915.         if do_time:
  916.             x.feed(data)
  917.             x.close()
  918.         else:
  919.             for c in data:
  920.                 x.feed(c)
  921.             
  922.             x.close()
  923.     except Error:
  924.         msg = None
  925.         t1 = time()
  926.         print msg
  927.         if do_time:
  928.             print 'total time: %g' % (t1 - t0)
  929.         sys.exit(1)
  930.  
  931.     t1 = time()
  932.     if do_time:
  933.         print 'total time: %g' % (t1 - t0)
  934.  
  935. if __name__ == '__main__':
  936.     test()
  937.